test/test_installation_history.py (1)

10-16: Confirm capitalized module name and consider PEP 8 alignment

Switching to from Installation_history import ... is fine if the module is actually named with a capital I. If the module is under your control, consider renaming it to a lowercase, underscore‑separated name and adjusting imports for PEP 8 compliance; otherwise, just ensure this import matches the real filename in the package layout.

src/intent/detector.py (1)

6-10: Tighten public API typing/docstrings for Intent and detect()

The detection logic itself looks solid and matches the intended flows. To better align with the project’s typing/docstring guidelines, consider:

• Making details more explicit than Optional[dict], e.g. Optional[dict[str, object]] or a typed alias if you expect a fixed structure.
• Adding a short docstring to Intent (or at least to detect) describing expected input text and the shape/ordering of returned intents.

This will make the new intent surface clearer to downstream callers and type checkers. As per coding guidelines, docstrings and strong type hints are expected on public APIs.

Also applies to: 26-49

src/intent/context.py (1)

13-69: Add explicit -> None return types on mutating SessionContext methods

SessionContext behavior looks fine, but several public methods (__init__, set_gpu, add_intents, add_installed, add_clarification, reset) currently omit their -> None return annotations. Adding these will fully satisfy the “type hints required” guideline and make intent clearer to type checkers:

-    def set_gpu(self, gpu_name: str):
+    def set_gpu(self, gpu_name: str) -> None:
@@
-    def add_intents(self, intents: List[Intent]):
+    def add_intents(self, intents: List[Intent]) -> None:
@@
-    def add_installed(self, pkg: str):
+    def add_installed(self, pkg: str) -> None:
@@
-    def add_clarification(self, question: str):
+    def add_clarification(self, question: str) -> None:
@@
-    def reset(self):
+    def reset(self) -> None:

(You can similarly annotate __init__ if you want full consistency.)

As per coding guidelines, type hints are required.

src/intent/planner.py (1)

6-49: Use GPU_PACKAGES in has_gpu and annotate it as ClassVar

Right now GPU_PACKAGES is never used, and has_gpu only checks for a gpu target, so a plan with only cuda/pytorch intents won’t trigger GPU detection/config steps. You can both fix this and satisfy the Ruff ClassVar warning by:

-from typing import List
+from typing import List, ClassVar
@@
-    GPU_PACKAGES = ["cuda", "cudnn", "pytorch", "tensorflow"]
+    GPU_PACKAGES: ClassVar[List[str]] = ["cuda", "cudnn", "pytorch", "tensorflow"]
@@
-        # 1. If GPU-related intents exist → add GPU detection
-        has_gpu = any(i.target == "gpu" for i in intents)
+        # 1. If GPU-related intents exist → add GPU detection
+        has_gpu = any(
+            i.target == "gpu" or i.target in self.GPU_PACKAGES
+            for i in intents
+        )

This keeps the behavior aligned with the intent of “GPU-related intents” while cleaning up the static-analysis complaint.

src/test_intent_detection.py (1)

1-15: Tests cover core detector behavior; type hints optional for consistency

These tests nicely exercise the happy path and an empty-input case for IntentDetector. If you want full alignment with the “type hints required” policy, you could add return annotations like def test_detector_basic() -> None, but that’s purely consistency polish on test code.

src/test_clarifier.py (1)

1-12: Clarifier integration test looks good; consider optional type annotations

The test correctly validates that a clarification question is produced for an underspecified ML request. As with the other tests, you could optionally add -> None on the test function to mirror the project’s typing convention, but the current test is functionally solid.

src/test_llm_agent.py (2)

3-9: Consider using a factory method or instance attribute for mutable content.

The content class attribute on line 8 is a mutable list. While this works for the current test, it could cause unexpected behavior if multiple Response instances share state. Since this is a simple mock, it's low risk, but using an instance attribute or property would be safer.

 class MockMessages:
     def create(self, **kwargs):
         class Response:
             class Content:
                 text = "install: tensorflow\ninstall: jupyter"
-            content = [Content()]
+            @property
+            def content(self):
+                return [self.Content()]
         return Response()

---

15-28: Test file location inconsistent with project structure.

This test file is in src/ while other NL parser tests are in tests/test_nl_parser.py. Consider moving to tests/test_llm_agent.py for consistency. Also, the test could benefit from additional assertions to verify the structure of the plan (e.g., that plan items are strings) and that suggestions is a list.

     assert "plan" in result
     assert len(result["plan"]) > 0
     assert "suggestions" in result
+    assert isinstance(result["plan"], list)
+    assert isinstance(result["suggestions"], list)

src/test_planner.py (1)

4-16: Test validates planner correctly; consider moving to tests/ and using constants.

The test properly validates the CUDA/PyTorch/GPU pipeline. Assertions against hardcoded strings (e.g., "Install CUDA 12.3 + drivers") may become brittle if planner output changes. Consider either:

1. Moving to tests/test_planner.py for consistency
2. Optionally defining expected plan steps as constants shared with the planner

Current test logic is correct.

src/intent/llm_agent.py (2)

67-70: Consider logging swallowed exceptions and using narrower exception types.

Bare except Exception catches can mask unexpected errors. While the fallback behavior is appropriate for resilience, logging the exception would aid debugging in production.

+import logging
+
+logger = logging.getLogger(__name__)
+
         # 4. Improve intents using LLM (safe)
         try:
             improved_intents = self.enhance_intents_with_llm(text, intents)
-        except Exception:
+        except Exception as e:
+            logger.warning("LLM enhancement failed, using rule-based intents: %s", e)
             improved_intents = intents

Also applies to: 79-82

---

100-106: LLM prompt may produce inconsistent output format.

The prompt at lines 96-106 asks for "install: package" format but doesn't strongly constrain the LLM output. Consider adding examples or using a more structured prompt to improve reliability of parsing.

 Return improvements or extra intents.
-Format: "install: package" or "configure: component"
+Format each intent on its own line using exactly one of:
+- install: <package_name>
+- configure: <component>
+- verify: <target>
+
+Example:
+install: tensorflow
+configure: gpu
 """

nl_parser.py (2)

142-142: Clarify deduplication idiom with a comment.

The dict.fromkeys() pattern for deduplication is clever but not immediately obvious to all readers.

Apply this diff:

-        slots["packages"] = list(dict.fromkeys(pkgs))  # unique preserve order
+        # Deduplicate while preserving order (dict.fromkeys maintains insertion order in Python 3.7+)
+        slots["packages"] = list(dict.fromkeys(pkgs))

---

173-220: Consider adding input length validation.

The function processes arbitrary-length text without validation. While not likely to be a practical issue for typical use cases, extremely long inputs could cause performance degradation.

Consider adding a length check at the start of the function:

 def parse_request(text: str) -> Dict[str, Any]:
     """Main function used by tests and demo."""
+    # Prevent potential DoS from extremely long inputs
+    if len(text) > 10000:
+        return {
+            "intent": "unknown",
+            "confidence": 0.0,
+            "explanation": "Input too long",
+            "slots": {},
+            "corrections": [],
+            "clarifications": ["Please provide a shorter request (max 10000 characters)"],
+        }
+    
     norm = normalize(text)

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: cortexlinux/cortex PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-12-11T12:03:24.071Z
Learning: Applies to **/*.py : Type hints required in Python code